home *** CD-ROM | disk | FTP | other *** search
/ MacHack 1997 / MacHack 1997.toast / Hacks / Hacks ’97 / Vertical Hold / source code / WavePlug.cpp < prev   
Encoding:
C/C++ Source or Header  |  1997-06-27  |  12.4 KB  |  496 lines  |  [TEXT/CWIE]
  1. #include <LowMem.h>
  2. #include <A4Stuff.h>
  3. #include <QuickDraw.h>
  4. #include <Memory.h>
  5. #include <Resources.h>
  6. #include <Fonts.h>
  7. #include <Dialogs.h>
  8. #include <QDOffscreen.h>
  9. #include <string.h>
  10. #include <stdio.h>
  11. #include <Timer.h>
  12.  
  13. int wavePos = 0;
  14. long waveVal[100] =
  15. {
  16.     0x000000, 0x010000, 0x030000, 0x040000, 0x060000, 0x070000, 0x090000, 0x0a0000, 0x0c0000, 0x0d0000,
  17.     0x0e0000, 0x0f0000, 0x110000, 0x120000, 0x130000, 0x140000, 0x150000, 0x150000, 0x160000, 0x170000,
  18.     0x170000, 0x180000, 0x180000, 0x180000, 0x180000, 0x180000, 0x180000, 0x180000, 0x180000, 0x180000,
  19.     0x170000, 0x170000, 0x160000, 0x150000, 0x150000, 0x140000, 0x130000, 0x120000, 0x110000, 0x0f0000,
  20.     0x0e0000, 0x0d0000, 0x0c0000, 0x0a0000, 0x090000, 0x070000, 0x060000, 0x040000, 0x030000, 0x010000,
  21.     0x000000,-0x020000,-0x040000,-0x050000,-0x070000,-0x080000,-0x0a0000,-0x0b0000,-0x0c0000,-0x0e0000,
  22.    -0x0f0000,-0x100000,-0x120000,-0x130000,-0x140000,-0x150000,-0x160000,-0x160000,-0x170000,-0x180000,
  23.    -0x180000,-0x190000,-0x190000,-0x190000,-0x190000,-0x190000,-0x190000,-0x190000,-0x190000,-0x190000,
  24.    -0x180000,-0x180000,-0x170000,-0x160000,-0x160000,-0x150000,-0x140000,-0x130000,-0x120000,-0x100000,
  25.    -0x0f0000,-0x0e0000,-0x0d0000,-0x0b0000,-0x0a0000,-0x080000,-0x070000,-0x050000,-0x040000,-0x020000
  26. };
  27.  
  28. long waveVal2[100] =
  29. {
  30.     0x00000, 0x00400, 0x00800, 0x00c00, 0x01000, 0x01800, 0x02000, 0x02800, 0x03000, 0x03400,
  31.     0x03800, 0x03c00, 0x04000, 0x04400, 0x04800, 0x04c00, 0x05000, 0x05800, 0x06000, 0x06800,
  32.     0x07000, 0x07800, 0x08000, 0x08800, 0x09000, 0x09400, 0x09800, 0x09c00, 0x0a000, 0x0a800,
  33.     0x0b000, 0x0b800, 0x0c000, 0x0c400, 0x0c800, 0x0cc00, 0x0d000, 0x0d400, 0x0d800, 0x0dc00,
  34.     0x0e000, 0x0e400, 0x0e800, 0x0ec00, 0x0f000, 0x0f800, 0x10000, 0x10800, 0x11000, 0x11400,
  35.     0x11800, 0x11c00, 0x12000, 0x12400, 0x12800, 0x12c00, 0x13000, 0x13400, 0x13800, 0x13c00,
  36.     0x14000, 0x14400, 0x14800, 0x14c00, 0x15000, 0x15200, 0x15400, 0x15600, 0x15800, 0x15a00,
  37.     0x15c00, 0x15e00, 0x16000, 0x16100, 0x16200, 0x16300, 0x16400, 0x16500, 0x16600, 0x16700,
  38.     0x16900, 0x16b00, 0x16d00, 0x17000, 0x17100, 0x17200, 0x17300, 0x17400, 0x17500, 0x17600,
  39.     0x17700, 0x17800, 0x17900, 0x17a00, 0x17b00, 0x17c00, 0x17d00, 0x17e00, 0x17f00, 0x18000
  40. };
  41.  
  42. char zeroBuffer[1024];
  43.  
  44. void initWavePlug();
  45. void initWavePlug()
  46. {
  47.     int i;
  48.     for(i = 0; i < 1024; i++)
  49.         zeroBuffer[i] = 255;
  50. }
  51.  
  52. void disposeWavePlug();
  53. void disposeWavePlug()
  54. {
  55. }
  56.  
  57. typedef struct {
  58.     TMTask            task;
  59.     Ptr                mainBaseAddr;
  60.     Size            worldBytes;
  61.     Ptr                worldBuffer;
  62.     short            rowBytes;
  63.     short            phase;
  64.     Rect            size;
  65.     short            offset;
  66. } MyTaskRec;
  67.  
  68. void doWavePlug(MyTaskRec* myTask);
  69. void doScrollerPlug(MyTaskRec* myTask);
  70. void doFallingDoorPlug(MyTaskRec* myTask);
  71. void doKaliedPlug(MyTaskRec* myTask);
  72. void doSlidePlug(MyTaskRec* myTask);
  73. void doMungePlug(MyTaskRec* myTask);
  74. void doPixelatorPlug(MyTaskRec* myTask);
  75. void doInvertPlug(MyTaskRec* myTask);
  76. void doSnowPlug(MyTaskRec* myTask);
  77.  
  78. int speed = 1;
  79. int scale = 0x10000;
  80. int dir = 0x400;
  81.  
  82. void doWavePlug(MyTaskRec* myTask)
  83. {
  84.     short            height = myTask -> size.bottom - myTask -> size.top;
  85.     short            phase = myTask -> phase;
  86.     short            rowBytes = myTask -> rowBytes;
  87.     Ptr                worldBuffer = myTask -> worldBuffer;
  88.     Ptr                screenBuffer = myTask -> mainBaseAddr;
  89.     
  90.     wavePos += speed;
  91.     if(wavePos > 99)
  92.     {
  93.         wavePos -= 100;
  94.         speed++;
  95.         if(speed > 4)
  96.             speed = 1;
  97.     }
  98.     scale += dir * speed;
  99.     if(scale > 0x40000)
  100.         dir = - dir;
  101.     if(scale < 0x08000)
  102.         dir = - dir;
  103.     
  104.     int i;
  105.     for(i = 0; i < height; i++)
  106.     {
  107.         long offset = waveVal[(wavePos + i) % 100] / scale;
  108.         
  109.         if(offset > 0)
  110.         {
  111.             ::BlockMoveData (worldBuffer + i * rowBytes,
  112.                             screenBuffer + i * rowBytes + offset,
  113.                             myTask->size.right - offset);
  114.         }
  115.         else
  116.         {
  117.             ::BlockMoveData (worldBuffer + i * rowBytes - offset,
  118.                             screenBuffer + i * rowBytes,
  119.                             myTask->size.right + offset);
  120.         }
  121.     }
  122. }
  123.  
  124. int doorPos = 0;
  125. int doorSpeed = 1;
  126.  
  127. void doFallingDoorPlug(MyTaskRec* myTask)
  128. {
  129.     short            height = myTask -> size.bottom - myTask -> size.top;
  130.     short            phase = myTask -> phase;
  131.     short            rowBytes = myTask -> rowBytes;
  132.     short            width = myTask->size.right;
  133.     Ptr                worldBuffer = myTask -> worldBuffer;
  134.     Ptr                screenBuffer = myTask -> mainBaseAddr;
  135.     
  136.     doorPos += doorSpeed;
  137.     if(doorPos > 99)
  138.     {
  139.         doorPos -= 100;
  140.         doorSpeed++;
  141.         if(doorSpeed > 4)
  142.             doorSpeed = 1;
  143.     }
  144.     
  145.     int destV;
  146.     int top = ((0x18000 - waveVal2[99 - doorPos]) * height) / 0x18000;
  147.     if(top >= height)
  148.         top = height - 1;
  149.     for(destV = 0; destV < height; destV++)
  150.     {
  151.         char *src = worldBuffer + destV * rowBytes;
  152.         char *dest = screenBuffer + destV * rowBytes;
  153.         if(destV < top)
  154.         {
  155.             ::BlockMoveData (zeroBuffer,
  156.                             screenBuffer + destV * rowBytes,
  157.                             width);
  158.         }
  159.         else
  160.         {
  161.             int srcV = ((destV - top) * (height)) / (height - top);
  162.         //    ::BlockMoveData (worldBuffer + srcV * rowBytes,
  163.         //                    screenBuffer + destV * rowBytes,
  164.         //                    width);
  165. //            int off = (destV - top)*(0x18000 - waveVal2[99 - doorPos]) / (0x800 *(height - top));// forward
  166.             int off = (height - destV)*(0x18000 - waveVal2[99 - doorPos]) / (0x400 *(height - top));
  167.             
  168.             ::BlockMoveData (zeroBuffer, screenBuffer + destV * rowBytes, off);
  169.             int xxx;
  170.             char *destbase = screenBuffer + destV * rowBytes + off;
  171.             char *base = worldBuffer + srcV * rowBytes;
  172.             int div = width - off * 2;
  173.             
  174.             for(xxx = 0; xxx < width - 2 * off; xxx++)
  175.             {
  176.                 *(destbase + xxx) = *(base + xxx * width / div);
  177.             }
  178.             
  179.             ::BlockMoveData (zeroBuffer, screenBuffer + destV * rowBytes + width - off, off);
  180.         }
  181.     }
  182. }
  183.  
  184. long scrollDirs[16] = 
  185. {
  186.     3, -4, -6, 5, -2, 0, 2, -3, 3, -7, 2, 5, -9, 1, 2, -2
  187. };
  188. long scrollPos[16] =
  189. {
  190.     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
  191. };
  192.  
  193.  
  194. void doScrollerPlug(MyTaskRec* myTask)
  195. {
  196.     short            height = myTask -> size.bottom - myTask -> size.top;
  197.     short            width = myTask->size.right;
  198.     short            phase = myTask -> phase;
  199.     short            rowBytes = myTask -> rowBytes;
  200.     Ptr                worldBuffer = myTask -> worldBuffer;
  201.     Ptr                screenBuffer = myTask -> mainBaseAddr;
  202.     
  203.     int i;
  204.     for(i = 0; i < 16; i++)
  205.     {
  206.         scrollPos[i] = (scrollPos[i] + scrollDirs[i]);
  207.         if(scrollPos[i] > width)
  208.             scrollPos[i] -= width;
  209.         if(scrollPos[i] < 0)
  210.             scrollPos[i] += width;
  211.     }
  212.     
  213.     for(i = 0; i < height; i++)
  214.     {
  215.         long offset = scrollPos[i * 16 / height];
  216.         
  217.         ::BlockMoveData (worldBuffer + i * rowBytes,
  218.                         screenBuffer + i * rowBytes + offset,
  219.                         width - offset);
  220.         ::BlockMoveData (worldBuffer + i * rowBytes + width - offset,
  221.                         screenBuffer + i * rowBytes,
  222.                         offset);
  223.     }
  224. }
  225.  
  226. int xphase = 0;
  227. int counter = 0;
  228.  
  229. void doKaliedPlug(MyTaskRec* myTask)
  230. {
  231.     short            height = myTask -> size.bottom - myTask -> size.top;
  232.     short            width = myTask->size.right;
  233.     short            phase = myTask -> phase;
  234.     short            rowBytes = myTask -> rowBytes;
  235.     Ptr                worldBuffer = myTask -> worldBuffer;
  236.     Ptr                screenBuffer = myTask -> mainBaseAddr;
  237.     
  238.     counter++;
  239.     if(counter > 250)
  240.     {
  241.         counter = 0;
  242.         xphase = (xphase + 1) % 4;
  243.     }
  244.     int i,j;
  245.     if(xphase == 0)
  246.     {
  247.         for(i = 0; i < height / 2; i++)
  248.         {
  249.             for(j = 0; j < width / 2; j++)
  250.             {
  251.                 char val = *(worldBuffer + i * rowBytes * 2 + j * 2);
  252.                 *(screenBuffer + i * rowBytes + j) = val;
  253.                 *(screenBuffer + i * rowBytes + width - j - 1) =  val;
  254.                 *(screenBuffer + (height - i - 1) * rowBytes + j) =  val;
  255.                 *(screenBuffer + (height - i - 1) * rowBytes + width - j - 1) =  val;
  256.             }
  257.         }
  258.     }    
  259.     else if(xphase == 1)
  260.     {
  261.         for(i = 0; i < height / 2; i++)
  262.         {
  263.             for(j = 0; j < width / 2; j++)
  264.             {
  265.                 char val = *(worldBuffer + i * rowBytes * 2 + j * 2);
  266.                 *(screenBuffer + i * rowBytes + width / 2 - j - 1) = val;
  267.                 *(screenBuffer + i * rowBytes + width / 2 + j) =  val;
  268.                 *(screenBuffer + (height - i - 1) * rowBytes + width / 2 - j - 1) =  val;
  269.                 *(screenBuffer + (height - i - 1) * rowBytes + width / 2 + j) =  val;
  270.             }
  271.         }
  272.     }    
  273.     else if(xphase == 2)
  274.     {
  275.         for(i = 0; i < height / 2; i++)
  276.         {
  277.             for(j = 0; j < width / 2; j++)
  278.             {
  279.                 char val = *(worldBuffer + i * rowBytes * 2 + j * 2);
  280.                 *(screenBuffer + ((height / 2) - i - 1) * rowBytes + j) = val;
  281.                 *(screenBuffer + ((height / 2) - i - 1) * rowBytes + width - j - 1) =  val;
  282.                 *(screenBuffer + (height / 2 + i) * rowBytes + j) =  val;
  283.                 *(screenBuffer + (height / 2 + i) * rowBytes + width - j - 1) =  val;
  284.             }
  285.         }
  286.     }    
  287.     else if(xphase == 3)
  288.     {
  289.         for(i = 0; i < height / 2; i++)
  290.         {
  291.             for(j = 0; j < width / 2; j++)
  292.             {
  293.                 char val = *(worldBuffer + i * rowBytes * 2 + j * 2);
  294.                 *(screenBuffer + ((height / 2) - i - 1) * rowBytes + width / 2 - j - 1) = val;
  295.                 *(screenBuffer + ((height / 2) - i - 1) * rowBytes + width / 2 + j) =  val;
  296.                 *(screenBuffer + (height / 2 + i) * rowBytes + width / 2 - j - 1) =  val;
  297.                 *(screenBuffer + (height / 2 + i) * rowBytes + width / 2 + j) =  val;
  298.             }
  299.         }
  300.     }    
  301.     
  302. }
  303.  
  304. int slidePos = 0;
  305.  
  306. void doSlidePlug(MyTaskRec* myTask)
  307. {
  308.     short            height = myTask -> size.bottom - myTask -> size.top;
  309.     short            width = myTask->size.right;
  310.     short            phase = myTask -> phase;
  311.     short            rowBytes = myTask -> rowBytes;
  312.     Ptr                worldBuffer = myTask -> worldBuffer;
  313.     Ptr                screenBuffer = myTask -> mainBaseAddr;
  314.     
  315.     int i;
  316.     slidePos++;
  317.     slidePos = (slidePos % 60);
  318.     for(i = 0; i < height; i++)
  319.     {
  320.         long offset = ((slidePos * i) / 20) % width;
  321.         
  322.         ::BlockMoveData (worldBuffer + i * rowBytes,
  323.                         screenBuffer + i * rowBytes + offset,
  324.                         width - offset);
  325.         ::BlockMoveData (worldBuffer + i * rowBytes + width - offset,
  326.                         screenBuffer + i * rowBytes,
  327.                         offset);
  328.     }
  329. }
  330.  
  331. char *memLoc = 0;
  332. void doSnowPlug(MyTaskRec* myTask)
  333. {
  334.     short            height = myTask -> size.bottom - myTask -> size.top;
  335.     short            phase = myTask -> phase;
  336.     short            rowBytes = myTask -> rowBytes;
  337.     Ptr                worldBuffer = myTask -> worldBuffer;
  338.     Ptr                screenBuffer = myTask -> mainBaseAddr;
  339.  
  340.     
  341.     int i;
  342.     for(i = 0; i < height; i++)
  343.     {
  344.         unsigned char ch;        
  345.         char *j;
  346.         char *k;
  347.         
  348.         k = screenBuffer + i * rowBytes;
  349.         for(j = worldBuffer + i * rowBytes; j <= worldBuffer + i * rowBytes + rowBytes - 1 ; j++)
  350.         {
  351.             memLoc++;
  352.             ch = *memLoc % 67;
  353.             
  354.             if(memLoc > (char *)0x00040000)
  355.                 memLoc = 0;;
  356.             
  357.             if(ch == 65)
  358.                 *k = 0;
  359.             else
  360.                 if(ch == 27)
  361.                     *k = 255;
  362.                 else
  363.                     *k = *j;
  364.  
  365.             k++;
  366.         }
  367.     }
  368. }
  369.  
  370. int invertPos = 0;
  371. void doInvertPlug(MyTaskRec* myTask)
  372. {
  373.     short            height = myTask -> size.bottom - myTask -> size.top;
  374.     short            phase = myTask -> phase;
  375.     short            rowBytes = myTask -> rowBytes;
  376.     Ptr                worldBuffer = myTask -> worldBuffer;
  377.     Ptr                screenBuffer = myTask -> mainBaseAddr;
  378.     short            width = myTask->size.right;
  379.     
  380.     invertPos++;
  381.     if(invertPos > 99)
  382.         invertPos = 0;
  383.     
  384.     int i;
  385.     for(i = 0; i < height; i++)
  386.     {
  387.         char *j;
  388.         char *k;
  389.         
  390.         k = screenBuffer + (height - i) * rowBytes;
  391.         for(j = worldBuffer + i * rowBytes + width - 1; j >= worldBuffer + i * rowBytes; j--)
  392.         {
  393.             *k = *j;
  394.             k++;
  395.         }
  396.     }
  397. }
  398.  
  399.  
  400. int pixelatorPos = 1;
  401. static Boolean    growing = true;
  402. void doPixelatorPlug(MyTaskRec* myTask)
  403. {
  404.     EnterCodeResource ();
  405.     short            height = myTask -> size.bottom - myTask -> size.top;
  406.     short            phase = myTask -> phase;
  407.     short            rowBytes = myTask -> rowBytes;
  408.     Ptr                worldBuffer = myTask -> worldBuffer;
  409.     Ptr                screenBuffer = myTask -> mainBaseAddr;
  410.     short            width = myTask->size.right;
  411.  
  412.     pixelatorPos+= growing ? 1 : -1;
  413.     
  414.     if(pixelatorPos > 5)
  415.     {
  416.         pixelatorPos = 5;
  417.         growing    = false;
  418.     }
  419.     if(pixelatorPos < 1)
  420.     {
  421.         pixelatorPos = 1;
  422.         growing = true;
  423.     }
  424.     
  425.     int i;
  426.     for(i = 0; i < height; i++)
  427.     {
  428.         char *j;
  429.         char *k;
  430.         
  431.         k = screenBuffer + i * rowBytes;
  432.         for(j = worldBuffer + i * rowBytes; j <= worldBuffer + i * rowBytes + width - 1 ; j+=pixelatorPos)
  433.         {
  434.             long l;
  435.             for(l = 0; l < pixelatorPos && (j+l <= worldBuffer + i * rowBytes + width - 1); l++)
  436.             {
  437.                 *k = *j;
  438.                 k++;
  439.             }
  440.         }
  441.     }
  442.     ExitCodeResource ();
  443. }
  444.  
  445.  
  446.  
  447. int mungePos = 0;
  448. int mungeVal[100] =
  449. {
  450.     0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  451.     21, -15, 17, 18, -12, -16, 0, 0, 0, 0,
  452.     0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  453.     21, -15, 17, 18, -12, -16, 0, 0, 0, 0,
  454.     0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  455.     0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  456.     0, 0, 0, 0, -16, -12, 18, 17, -15, 21,
  457.     0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  458.     0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  459.     0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  460. };
  461.  
  462. void doMungePlug(MyTaskRec* myTask)
  463. {
  464.     EnterCodeResource ();
  465.     short            height = myTask -> size.bottom - myTask -> size.top;
  466.     short            phase = myTask -> phase;
  467.     short            rowBytes = myTask -> rowBytes;
  468.     Ptr                worldBuffer = myTask -> worldBuffer;
  469.     Ptr                screenBuffer = myTask -> mainBaseAddr;
  470.  
  471.     mungePos++;
  472.     if(mungePos > 99)
  473.         mungePos = 0;
  474.     
  475.     int i;
  476.     for(i = 0; i < height; i++)
  477.     {
  478.         long offset = mungeVal[(mungePos + i) % 100];
  479.         
  480.         if(offset > 0)
  481.         {
  482.             ::BlockMoveData (worldBuffer + i * rowBytes,
  483.                         screenBuffer + i * rowBytes + offset,
  484.                         rowBytes);
  485.         }
  486.         else
  487.         {
  488.             ::BlockMoveData (worldBuffer + i * rowBytes - offset,
  489.                         screenBuffer + i * rowBytes,
  490.                         rowBytes);
  491.         }
  492.     }
  493.     ExitCodeResource ();
  494. }
  495.  
  496.